﻿namespace DesignModeConsole.行为型.职责链模式;

#region 方案一优化后

/// <summary>
/// 所有处理器类的抽象父类  使用模板模式抽离逻辑到抽象父类
/// </summary>
public abstract class Handler1_2
{
    private Handler1_2? _successor;

    public void SetNextHandler(Handler1_2? successor)
    {
        this._successor = successor;
    }

    /// <summary>
    /// 将_successor.Handle的逻辑从具体的处理器类中剥离出来，放到抽象父类中，
    /// 这样子具体的处理器类就只需要实现自己的业务逻辑就可以了
    /// </summary>
    public void Handle()
    {
        var handled = DoHandle();
        // 如果前一个处理成功那么就不往下继续执行了
        if (_successor != null && !handled)
        {
            _successor.Handle();
        }
    }

    /// <summary>
    /// 进行处理  返回处理的成功不成功
    /// </summary>
    /// <returns></returns>
    protected abstract bool DoHandle();
}

public class Handler1A1_2 : Handler1_2
{
    protected override bool DoHandle()
    {
        Console.WriteLine("开始处理HandlerA 第一个");
        var handled = false;
        // 业务逻辑处理 判断是否可以处理
        return handled;
    }
}

public class Handler1B1_2 : Handler1_2
{
    protected override bool DoHandle()
    {
        Console.WriteLine("开始处理HandlerB 第二个");
        var handled = false;
        // 业务逻辑处理 判断是否可以处理
        return handled;
    }
}

/// <summary>
/// 使用链表的形式保存所有的处理器
/// </summary>
public class HandlerChain1_2
{
    /// <summary>
    /// 处理器链头
    /// </summary>
    private Handler1_2? head;

    /// <summary>
    /// 处理器链尾 结尾
    /// </summary>
    private Handler1_2? tail;

    public void AddHandler(Handler1_2 handler)
    {
        // 设置当前下一个为null
        handler.SetNextHandler(null);
        if (head is null)
        {
            // 设置开始和结束的hander
            head = handler;
            tail = handler;
            return;
        }

        // 把当前处理器作为上一个节点下一级别
        tail.SetNextHandler(handler);

        // 把当前的处理器给最后一个节点，这个时候head保存的是层级的处理程序
        tail = handler;
    }

    public void Handle()
    {
        head?.Handle();
    }
}

#endregion

#region 方案一优化前

/// <summary>
/// 所有处理器类的抽象父类
/// </summary>
public abstract class Handler1
{
    protected Handler1? Successor;

    public void SetSuccessor(Handler1? successor)
    {
        this.Successor = successor;
    }

    public abstract void Handle();
}

public class Handler1A : Handler1
{
    public override void Handle()
    {
        Console.WriteLine("开始处理HandlerA");
        var handled = false;
        // 业务逻辑处理 然后发现当前处理不了该请求，继续往下传递
        if (!handled && Successor is not null)
        {
            Successor.Handle();
        }

        Console.WriteLine("处理结束HandlerA");
    }
}

public class Handler1B : Handler1
{
    public override void Handle()
    {
        Console.WriteLine("开始处理HandlerB");
        var handled = false;
        // 业务逻辑处理，发现不可以处理该请求，所以就继续往下传递
        if (!handled && Successor is not null)
        {
            Successor.Handle();
        }

        Console.WriteLine("开始处理HandlerB");
    }
}

public class HandlerChain1
{
    /// <summary>
    /// 处理器链头
    /// </summary>
    private Handler1? head;

    /// <summary>
    /// 处理器链尾
    /// </summary>
    private Handler1? tail;

    public void AddHandler(Handler1? handler)
    {
        // 将这个处理器类的下一个处理设置为null
        handler.SetSuccessor(null);
        if (head is null)
        {
            head = handler;
            tail = handler;
            return;
        }

        tail.SetSuccessor(handler);
        tail = handler;
    }

    public void Handle()
    {
        if (head is not null)
        {
            head.Handle();
        }
    }
}

#endregion